/*
 * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The OpenAirInterface Software Alliance licenses this file to You under
 * the OAI Public License, Version 1.1  (the "License"); you may not use this file
 * except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.openairinterface.org/?page_id=698
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *-------------------------------------------------------------------------------
 * For more information about the OpenAirInterface (OAI) Software Alliance:
 *      contact@openairinterface.org
 */



#ifndef IE_DEFINITIONS_BUILDER_H
#define IE_DEFINITIONS_BUILDER_H

/* Generated by flatcc 0.6.1-dev FlatBuffers schema compiler for C by dvide.com */

#ifndef IE_DEFINITIONS_READER_H
#include "ie_definitions_reader.h"
#endif
#ifndef FLATBUFFERS_COMMON_BUILDER_H
#include "flatbuffers_common_builder.h"
#endif
#include "flatcc/flatcc_prologue.h"
#ifndef flatbuffers_identifier
#define flatbuffers_identifier 0
#endif
#ifndef flatbuffers_extension
#define flatbuffers_extension ".bin"
#endif

#define __e2ap_RicRequestCause_formal_args , e2ap_RicRequestCause_enum_t v0
#define __e2ap_RicRequestCause_call_args , v0
__flatbuffers_build_scalar(flatbuffers_, e2ap_RicRequestCause, e2ap_RicRequestCause_enum_t)
#define __e2ap_RicServiceCause_formal_args , e2ap_RicServiceCause_enum_t v0
#define __e2ap_RicServiceCause_call_args , v0
__flatbuffers_build_scalar(flatbuffers_, e2ap_RicServiceCause, e2ap_RicServiceCause_enum_t)
#define __e2ap_TransportLayerCause_formal_args , e2ap_TransportLayerCause_enum_t v0
#define __e2ap_TransportLayerCause_call_args , v0
__flatbuffers_build_scalar(flatbuffers_, e2ap_TransportLayerCause, e2ap_TransportLayerCause_enum_t)
#define __e2ap_ProtocolCause_formal_args , e2ap_ProtocolCause_enum_t v0
#define __e2ap_ProtocolCause_call_args , v0
__flatbuffers_build_scalar(flatbuffers_, e2ap_ProtocolCause, e2ap_ProtocolCause_enum_t)
#define __e2ap_MiscellaneousCause_formal_args , e2ap_MiscellaneousCause_enum_t v0
#define __e2ap_MiscellaneousCause_call_args , v0
__flatbuffers_build_scalar(flatbuffers_, e2ap_MiscellaneousCause, e2ap_MiscellaneousCause_enum_t)
#define __e2ap_Criticality_formal_args , e2ap_Criticality_enum_t v0
#define __e2ap_Criticality_call_args , v0
__flatbuffers_build_scalar(flatbuffers_, e2ap_Criticality, e2ap_Criticality_enum_t)
#define __e2ap_TypeOfError_formal_args , e2ap_TypeOfError_enum_t v0
#define __e2ap_TypeOfError_call_args , v0
__flatbuffers_build_scalar(flatbuffers_, e2ap_TypeOfError, e2ap_TypeOfError_enum_t)
#define __e2ap_TriggeringMessage_formal_args , e2ap_TriggeringMessage_enum_t v0
#define __e2ap_TriggeringMessage_call_args , v0
__flatbuffers_build_scalar(flatbuffers_, e2ap_TriggeringMessage, e2ap_TriggeringMessage_enum_t)
#define __e2ap_ProcedureCriticality_formal_args , e2ap_ProcedureCriticality_enum_t v0
#define __e2ap_ProcedureCriticality_call_args , v0
__flatbuffers_build_scalar(flatbuffers_, e2ap_ProcedureCriticality, e2ap_ProcedureCriticality_enum_t)
#define __e2ap_RicActionType_formal_args , e2ap_RicActionType_enum_t v0
#define __e2ap_RicActionType_call_args , v0
__flatbuffers_build_scalar(flatbuffers_, e2ap_RicActionType, e2ap_RicActionType_enum_t)
#define __e2ap_RicSubsequentActionType_formal_args , e2ap_RicSubsequentActionType_enum_t v0
#define __e2ap_RicSubsequentActionType_call_args , v0
__flatbuffers_build_scalar(flatbuffers_, e2ap_RicSubsequentActionType, e2ap_RicSubsequentActionType_enum_t)
#define __e2ap_RicIndicationType_formal_args , e2ap_RicIndicationType_enum_t v0
#define __e2ap_RicIndicationType_call_args , v0
__flatbuffers_build_scalar(flatbuffers_, e2ap_RicIndicationType, e2ap_RicIndicationType_enum_t)
#define __e2ap_RicControlAckRequest_formal_args , e2ap_RicControlAckRequest_enum_t v0
#define __e2ap_RicControlAckRequest_call_args , v0
__flatbuffers_build_scalar(flatbuffers_, e2ap_RicControlAckRequest, e2ap_RicControlAckRequest_enum_t)
#define __e2ap_RicControlStatus_formal_args , e2ap_RicControlStatus_enum_t v0
#define __e2ap_RicControlStatus_call_args , v0
__flatbuffers_build_scalar(flatbuffers_, e2ap_RicControlStatus, e2ap_RicControlStatus_enum_t)
#define __e2ap_E2NodeCompType_formal_args , e2ap_E2NodeCompType_enum_t v0
#define __e2ap_E2NodeCompType_call_args , v0
__flatbuffers_build_scalar(flatbuffers_, e2ap_E2NodeCompType, e2ap_E2NodeCompType_enum_t)
#define __e2ap_E2NodeCompConfUpdateAckOutcome_formal_args , e2ap_E2NodeCompConfUpdateAckOutcome_enum_t v0
#define __e2ap_E2NodeCompConfUpdateAckOutcome_call_args , v0
__flatbuffers_build_scalar(flatbuffers_, e2ap_E2NodeCompConfUpdateAckOutcome, e2ap_E2NodeCompConfUpdateAckOutcome_enum_t)

#define __e2ap_RicRequestId_formal_args , uint16_t v0, uint16_t v1
#define __e2ap_RicRequestId_call_args , v0, v1
static inline e2ap_RicRequestId_t *e2ap_RicRequestId_assign(e2ap_RicRequestId_t *p, uint16_t v0, uint16_t v1)
{ p->ricRequestorId = v0; p->ricInstanceId = v1;
  return p; }
static inline e2ap_RicRequestId_t *e2ap_RicRequestId_copy(e2ap_RicRequestId_t *p, const e2ap_RicRequestId_t *p2)
{ p->ricRequestorId = p2->ricRequestorId; p->ricInstanceId = p2->ricInstanceId;
  return p; }
static inline e2ap_RicRequestId_t *e2ap_RicRequestId_assign_to_pe(e2ap_RicRequestId_t *p, uint16_t v0, uint16_t v1)
{ flatbuffers_uint16_assign_to_pe(&p->ricRequestorId, v0); flatbuffers_uint16_assign_to_pe(&p->ricInstanceId, v1);
  return p; }
static inline e2ap_RicRequestId_t *e2ap_RicRequestId_copy_to_pe(e2ap_RicRequestId_t *p, const e2ap_RicRequestId_t *p2)
{ flatbuffers_uint16_copy_to_pe(&p->ricRequestorId, &p2->ricRequestorId); flatbuffers_uint16_copy_to_pe(&p->ricInstanceId, &p2->ricInstanceId);
  return p; }
static inline e2ap_RicRequestId_t *e2ap_RicRequestId_assign_from_pe(e2ap_RicRequestId_t *p, uint16_t v0, uint16_t v1)
{ flatbuffers_uint16_assign_from_pe(&p->ricRequestorId, v0); flatbuffers_uint16_assign_from_pe(&p->ricInstanceId, v1);
  return p; }
static inline e2ap_RicRequestId_t *e2ap_RicRequestId_copy_from_pe(e2ap_RicRequestId_t *p, const e2ap_RicRequestId_t *p2)
{ flatbuffers_uint16_copy_from_pe(&p->ricRequestorId, &p2->ricRequestorId); flatbuffers_uint16_copy_from_pe(&p->ricInstanceId, &p2->ricInstanceId);
  return p; }
__flatbuffers_build_struct(flatbuffers_, e2ap_RicRequestId, 4, 2, e2ap_RicRequestId_file_identifier, e2ap_RicRequestId_type_identifier)
__flatbuffers_define_fixed_array_primitives(flatbuffers_, e2ap_RicRequestId, e2ap_RicRequestId_t)

#define __e2ap_E2NCId_formal_args , uint64_t v0
#define __e2ap_E2NCId_call_args , v0
static inline e2ap_E2NCId_t *e2ap_E2NCId_assign(e2ap_E2NCId_t *p, uint64_t v0)
{ p->id = v0;
  return p; }
static inline e2ap_E2NCId_t *e2ap_E2NCId_copy(e2ap_E2NCId_t *p, const e2ap_E2NCId_t *p2)
{ p->id = p2->id;
  return p; }
static inline e2ap_E2NCId_t *e2ap_E2NCId_assign_to_pe(e2ap_E2NCId_t *p, uint64_t v0)
{ flatbuffers_uint64_assign_to_pe(&p->id, v0);
  return p; }
static inline e2ap_E2NCId_t *e2ap_E2NCId_copy_to_pe(e2ap_E2NCId_t *p, const e2ap_E2NCId_t *p2)
{ flatbuffers_uint64_copy_to_pe(&p->id, &p2->id);
  return p; }
static inline e2ap_E2NCId_t *e2ap_E2NCId_assign_from_pe(e2ap_E2NCId_t *p, uint64_t v0)
{ flatbuffers_uint64_assign_from_pe(&p->id, v0);
  return p; }
static inline e2ap_E2NCId_t *e2ap_E2NCId_copy_from_pe(e2ap_E2NCId_t *p, const e2ap_E2NCId_t *p2)
{ flatbuffers_uint64_copy_from_pe(&p->id, &p2->id);
  return p; }
__flatbuffers_build_struct(flatbuffers_, e2ap_E2NCId, 8, 8, e2ap_E2NCId_file_identifier, e2ap_E2NCId_type_identifier)
__flatbuffers_define_fixed_array_primitives(flatbuffers_, e2ap_E2NCId, e2ap_E2NCId_t)

#define __e2ap_Plmn_formal_args , uint16_t v0, uint16_t v1, uint8_t v2
#define __e2ap_Plmn_call_args , v0, v1, v2
static inline e2ap_Plmn_t *e2ap_Plmn_assign(e2ap_Plmn_t *p, uint16_t v0, uint16_t v1, uint8_t v2)
{ p->mcc = v0; p->mnc = v1; p->mnc_digit_length = v2;
  return p; }
static inline e2ap_Plmn_t *e2ap_Plmn_copy(e2ap_Plmn_t *p, const e2ap_Plmn_t *p2)
{ p->mcc = p2->mcc; p->mnc = p2->mnc; p->mnc_digit_length = p2->mnc_digit_length;
  return p; }
static inline e2ap_Plmn_t *e2ap_Plmn_assign_to_pe(e2ap_Plmn_t *p, uint16_t v0, uint16_t v1, uint8_t v2)
{ flatbuffers_uint16_assign_to_pe(&p->mcc, v0); flatbuffers_uint16_assign_to_pe(&p->mnc, v1); p->mnc_digit_length = v2;
  return p; }
static inline e2ap_Plmn_t *e2ap_Plmn_copy_to_pe(e2ap_Plmn_t *p, const e2ap_Plmn_t *p2)
{ flatbuffers_uint16_copy_to_pe(&p->mcc, &p2->mcc); flatbuffers_uint16_copy_to_pe(&p->mnc, &p2->mnc); p->mnc_digit_length = p2->mnc_digit_length;
  return p; }
static inline e2ap_Plmn_t *e2ap_Plmn_assign_from_pe(e2ap_Plmn_t *p, uint16_t v0, uint16_t v1, uint8_t v2)
{ flatbuffers_uint16_assign_from_pe(&p->mcc, v0); flatbuffers_uint16_assign_from_pe(&p->mnc, v1); p->mnc_digit_length = v2;
  return p; }
static inline e2ap_Plmn_t *e2ap_Plmn_copy_from_pe(e2ap_Plmn_t *p, const e2ap_Plmn_t *p2)
{ flatbuffers_uint16_copy_from_pe(&p->mcc, &p2->mcc); flatbuffers_uint16_copy_from_pe(&p->mnc, &p2->mnc); p->mnc_digit_length = p2->mnc_digit_length;
  return p; }
__flatbuffers_build_struct(flatbuffers_, e2ap_Plmn, 6, 2, e2ap_Plmn_file_identifier, e2ap_Plmn_type_identifier)
__flatbuffers_define_fixed_array_primitives(flatbuffers_, e2ap_Plmn, e2ap_Plmn_t)

#define __e2ap_EngNB_formal_args , uint16_t v0, uint16_t v1, uint8_t v2, uint32_t v3
#define __e2ap_EngNB_call_args , v0, v1, v2, v3
static inline e2ap_EngNB_t *e2ap_EngNB_assign(e2ap_EngNB_t *p, uint16_t v0, uint16_t v1, uint8_t v2, uint32_t v3)
{ e2ap_Plmn_assign(&p->plmn, v0, v1, v2); p->id = v3;
  return p; }
static inline e2ap_EngNB_t *e2ap_EngNB_copy(e2ap_EngNB_t *p, const e2ap_EngNB_t *p2)
{ e2ap_Plmn_copy(&p->plmn, &p2->plmn); p->id = p2->id;
  return p; }
static inline e2ap_EngNB_t *e2ap_EngNB_assign_to_pe(e2ap_EngNB_t *p, uint16_t v0, uint16_t v1, uint8_t v2, uint32_t v3)
{ e2ap_Plmn_assign_to_pe(&p->plmn, v0, v1, v2); flatbuffers_uint32_assign_to_pe(&p->id, v3);
  return p; }
static inline e2ap_EngNB_t *e2ap_EngNB_copy_to_pe(e2ap_EngNB_t *p, const e2ap_EngNB_t *p2)
{ e2ap_Plmn_copy_to_pe(&p->plmn, &p2->plmn); flatbuffers_uint32_copy_to_pe(&p->id, &p2->id);
  return p; }
static inline e2ap_EngNB_t *e2ap_EngNB_assign_from_pe(e2ap_EngNB_t *p, uint16_t v0, uint16_t v1, uint8_t v2, uint32_t v3)
{ e2ap_Plmn_assign_from_pe(&p->plmn, v0, v1, v2); flatbuffers_uint32_assign_from_pe(&p->id, v3);
  return p; }
static inline e2ap_EngNB_t *e2ap_EngNB_copy_from_pe(e2ap_EngNB_t *p, const e2ap_EngNB_t *p2)
{ e2ap_Plmn_copy_from_pe(&p->plmn, &p2->plmn); flatbuffers_uint32_copy_from_pe(&p->id, &p2->id);
  return p; }
__flatbuffers_build_struct(flatbuffers_, e2ap_EngNB, 12, 4, e2ap_EngNB_file_identifier, e2ap_EngNB_type_identifier)
__flatbuffers_define_fixed_array_primitives(flatbuffers_, e2ap_EngNB, e2ap_EngNB_t)

#define __e2ap_NgeNB_formal_args , uint16_t v0, uint16_t v1, uint8_t v2, uint32_t v3
#define __e2ap_NgeNB_call_args , v0, v1, v2, v3
static inline e2ap_NgeNB_t *e2ap_NgeNB_assign(e2ap_NgeNB_t *p, uint16_t v0, uint16_t v1, uint8_t v2, uint32_t v3)
{ e2ap_Plmn_assign(&p->plmn, v0, v1, v2); p->id = v3;
  return p; }
static inline e2ap_NgeNB_t *e2ap_NgeNB_copy(e2ap_NgeNB_t *p, const e2ap_NgeNB_t *p2)
{ e2ap_Plmn_copy(&p->plmn, &p2->plmn); p->id = p2->id;
  return p; }
static inline e2ap_NgeNB_t *e2ap_NgeNB_assign_to_pe(e2ap_NgeNB_t *p, uint16_t v0, uint16_t v1, uint8_t v2, uint32_t v3)
{ e2ap_Plmn_assign_to_pe(&p->plmn, v0, v1, v2); flatbuffers_uint32_assign_to_pe(&p->id, v3);
  return p; }
static inline e2ap_NgeNB_t *e2ap_NgeNB_copy_to_pe(e2ap_NgeNB_t *p, const e2ap_NgeNB_t *p2)
{ e2ap_Plmn_copy_to_pe(&p->plmn, &p2->plmn); flatbuffers_uint32_copy_to_pe(&p->id, &p2->id);
  return p; }
static inline e2ap_NgeNB_t *e2ap_NgeNB_assign_from_pe(e2ap_NgeNB_t *p, uint16_t v0, uint16_t v1, uint8_t v2, uint32_t v3)
{ e2ap_Plmn_assign_from_pe(&p->plmn, v0, v1, v2); flatbuffers_uint32_assign_from_pe(&p->id, v3);
  return p; }
static inline e2ap_NgeNB_t *e2ap_NgeNB_copy_from_pe(e2ap_NgeNB_t *p, const e2ap_NgeNB_t *p2)
{ e2ap_Plmn_copy_from_pe(&p->plmn, &p2->plmn); flatbuffers_uint32_copy_from_pe(&p->id, &p2->id);
  return p; }
__flatbuffers_build_struct(flatbuffers_, e2ap_NgeNB, 12, 4, e2ap_NgeNB_file_identifier, e2ap_NgeNB_type_identifier)
__flatbuffers_define_fixed_array_primitives(flatbuffers_, e2ap_NgeNB, e2ap_NgeNB_t)

#define __e2ap_ENB_formal_args , uint16_t v0, uint16_t v1, uint8_t v2, uint32_t v3
#define __e2ap_ENB_call_args , v0, v1, v2, v3
static inline e2ap_ENB_t *e2ap_ENB_assign(e2ap_ENB_t *p, uint16_t v0, uint16_t v1, uint8_t v2, uint32_t v3)
{ e2ap_Plmn_assign(&p->plmn, v0, v1, v2); p->id = v3;
  return p; }
static inline e2ap_ENB_t *e2ap_ENB_copy(e2ap_ENB_t *p, const e2ap_ENB_t *p2)
{ e2ap_Plmn_copy(&p->plmn, &p2->plmn); p->id = p2->id;
  return p; }
static inline e2ap_ENB_t *e2ap_ENB_assign_to_pe(e2ap_ENB_t *p, uint16_t v0, uint16_t v1, uint8_t v2, uint32_t v3)
{ e2ap_Plmn_assign_to_pe(&p->plmn, v0, v1, v2); flatbuffers_uint32_assign_to_pe(&p->id, v3);
  return p; }
static inline e2ap_ENB_t *e2ap_ENB_copy_to_pe(e2ap_ENB_t *p, const e2ap_ENB_t *p2)
{ e2ap_Plmn_copy_to_pe(&p->plmn, &p2->plmn); flatbuffers_uint32_copy_to_pe(&p->id, &p2->id);
  return p; }
static inline e2ap_ENB_t *e2ap_ENB_assign_from_pe(e2ap_ENB_t *p, uint16_t v0, uint16_t v1, uint8_t v2, uint32_t v3)
{ e2ap_Plmn_assign_from_pe(&p->plmn, v0, v1, v2); flatbuffers_uint32_assign_from_pe(&p->id, v3);
  return p; }
static inline e2ap_ENB_t *e2ap_ENB_copy_from_pe(e2ap_ENB_t *p, const e2ap_ENB_t *p2)
{ e2ap_Plmn_copy_from_pe(&p->plmn, &p2->plmn); flatbuffers_uint32_copy_from_pe(&p->id, &p2->id);
  return p; }
__flatbuffers_build_struct(flatbuffers_, e2ap_ENB, 12, 4, e2ap_ENB_file_identifier, e2ap_ENB_type_identifier)
__flatbuffers_define_fixed_array_primitives(flatbuffers_, e2ap_ENB, e2ap_ENB_t)

typedef flatbuffers_union_ref_t e2ap_Cause_union_ref_t;
typedef flatbuffers_union_vec_ref_t e2ap_Cause_union_vec_ref_t;
static e2ap_Cause_union_ref_t e2ap_Cause_clone(flatbuffers_builder_t *B, e2ap_Cause_union_t t);
typedef flatbuffers_union_ref_t e2ap_GlobalE2NodeId_union_ref_t;
typedef flatbuffers_union_vec_ref_t e2ap_GlobalE2NodeId_union_vec_ref_t;
static e2ap_GlobalE2NodeId_union_ref_t e2ap_GlobalE2NodeId_clone(flatbuffers_builder_t *B, e2ap_GlobalE2NodeId_union_t t);
typedef flatbuffers_union_ref_t e2ap_E2NodeCompConfUpdate_union_ref_t;
typedef flatbuffers_union_vec_ref_t e2ap_E2NodeCompConfUpdate_union_vec_ref_t;
static e2ap_E2NodeCompConfUpdate_union_ref_t e2ap_E2NodeCompConfUpdate_clone(flatbuffers_builder_t *B, e2ap_E2NodeCompConfUpdate_union_t t);
typedef flatbuffers_union_ref_t e2ap_E2NodeCompId_union_ref_t;
typedef flatbuffers_union_vec_ref_t e2ap_E2NodeCompId_union_vec_ref_t;
static e2ap_E2NodeCompId_union_ref_t e2ap_E2NodeCompId_clone(flatbuffers_builder_t *B, e2ap_E2NodeCompId_union_t t);

static const flatbuffers_voffset_t __e2ap_RicRequest_required[] = { 0 };
typedef flatbuffers_ref_t e2ap_RicRequest_ref_t;
static e2ap_RicRequest_ref_t e2ap_RicRequest_clone(flatbuffers_builder_t *B, e2ap_RicRequest_table_t t);
__flatbuffers_build_table(flatbuffers_, e2ap_RicRequest, 1)

static const flatbuffers_voffset_t __e2ap_RicService_required[] = { 0 };
typedef flatbuffers_ref_t e2ap_RicService_ref_t;
static e2ap_RicService_ref_t e2ap_RicService_clone(flatbuffers_builder_t *B, e2ap_RicService_table_t t);
__flatbuffers_build_table(flatbuffers_, e2ap_RicService, 1)

static const flatbuffers_voffset_t __e2ap_TransportLayer_required[] = { 0 };
typedef flatbuffers_ref_t e2ap_TransportLayer_ref_t;
static e2ap_TransportLayer_ref_t e2ap_TransportLayer_clone(flatbuffers_builder_t *B, e2ap_TransportLayer_table_t t);
__flatbuffers_build_table(flatbuffers_, e2ap_TransportLayer, 1)

static const flatbuffers_voffset_t __e2ap_Protocol_required[] = { 0 };
typedef flatbuffers_ref_t e2ap_Protocol_ref_t;
static e2ap_Protocol_ref_t e2ap_Protocol_clone(flatbuffers_builder_t *B, e2ap_Protocol_table_t t);
__flatbuffers_build_table(flatbuffers_, e2ap_Protocol, 1)

static const flatbuffers_voffset_t __e2ap_Misc_required[] = { 0 };
typedef flatbuffers_ref_t e2ap_Misc_ref_t;
static e2ap_Misc_ref_t e2ap_Misc_clone(flatbuffers_builder_t *B, e2ap_Misc_table_t t);
__flatbuffers_build_table(flatbuffers_, e2ap_Misc, 1)

static const flatbuffers_voffset_t __e2ap_IECriticalityDiagnostics_required[] = { 0 };
typedef flatbuffers_ref_t e2ap_IECriticalityDiagnostics_ref_t;
static e2ap_IECriticalityDiagnostics_ref_t e2ap_IECriticalityDiagnostics_clone(flatbuffers_builder_t *B, e2ap_IECriticalityDiagnostics_table_t t);
__flatbuffers_build_table(flatbuffers_, e2ap_IECriticalityDiagnostics, 3)

static const flatbuffers_voffset_t __e2ap_CriticalityDiagnostics_required[] = { 0 };
typedef flatbuffers_ref_t e2ap_CriticalityDiagnostics_ref_t;
static e2ap_CriticalityDiagnostics_ref_t e2ap_CriticalityDiagnostics_clone(flatbuffers_builder_t *B, e2ap_CriticalityDiagnostics_table_t t);
__flatbuffers_build_table(flatbuffers_, e2ap_CriticalityDiagnostics, 4)

static const flatbuffers_voffset_t __e2ap_GlobalRicId_required[] = { 0 };
typedef flatbuffers_ref_t e2ap_GlobalRicId_ref_t;
static e2ap_GlobalRicId_ref_t e2ap_GlobalRicId_clone(flatbuffers_builder_t *B, e2ap_GlobalRicId_table_t t);
__flatbuffers_build_table(flatbuffers_, e2ap_GlobalRicId, 2)

static const flatbuffers_voffset_t __e2ap_RicSubsequentAction_required[] = { 0 };
typedef flatbuffers_ref_t e2ap_RicSubsequentAction_ref_t;
static e2ap_RicSubsequentAction_ref_t e2ap_RicSubsequentAction_clone(flatbuffers_builder_t *B, e2ap_RicSubsequentAction_table_t t);
__flatbuffers_build_table(flatbuffers_, e2ap_RicSubsequentAction, 2)

static const flatbuffers_voffset_t __e2ap_gnbE2NodeCompConfUpdate_required[] = { 0 };
typedef flatbuffers_ref_t e2ap_gnbE2NodeCompConfUpdate_ref_t;
static e2ap_gnbE2NodeCompConfUpdate_ref_t e2ap_gnbE2NodeCompConfUpdate_clone(flatbuffers_builder_t *B, e2ap_gnbE2NodeCompConfUpdate_table_t t);
__flatbuffers_build_table(flatbuffers_, e2ap_gnbE2NodeCompConfUpdate, 4)

static const flatbuffers_voffset_t __e2ap_en_gnbE2NodeCompConfUpdate_required[] = { 0 };
typedef flatbuffers_ref_t e2ap_en_gnbE2NodeCompConfUpdate_ref_t;
static e2ap_en_gnbE2NodeCompConfUpdate_ref_t e2ap_en_gnbE2NodeCompConfUpdate_clone(flatbuffers_builder_t *B, e2ap_en_gnbE2NodeCompConfUpdate_table_t t);
__flatbuffers_build_table(flatbuffers_, e2ap_en_gnbE2NodeCompConfUpdate, 1)

static const flatbuffers_voffset_t __e2ap_ng_enbE2NodeCompConfUpdate_required[] = { 0 };
typedef flatbuffers_ref_t e2ap_ng_enbE2NodeCompConfUpdate_ref_t;
static e2ap_ng_enbE2NodeCompConfUpdate_ref_t e2ap_ng_enbE2NodeCompConfUpdate_clone(flatbuffers_builder_t *B, e2ap_ng_enbE2NodeCompConfUpdate_table_t t);
__flatbuffers_build_table(flatbuffers_, e2ap_ng_enbE2NodeCompConfUpdate, 2)

static const flatbuffers_voffset_t __e2ap_enbE2NodeCompConfUpdate_required[] = { 0 };
typedef flatbuffers_ref_t e2ap_enbE2NodeCompConfUpdate_ref_t;
static e2ap_enbE2NodeCompConfUpdate_ref_t e2ap_enbE2NodeCompConfUpdate_clone(flatbuffers_builder_t *B, e2ap_enbE2NodeCompConfUpdate_table_t t);
__flatbuffers_build_table(flatbuffers_, e2ap_enbE2NodeCompConfUpdate, 2)

static const flatbuffers_voffset_t __e2ap_E2NodeCompConfUpdateAck_required[] = { 0 };
typedef flatbuffers_ref_t e2ap_E2NodeCompConfUpdateAck_ref_t;
static e2ap_E2NodeCompConfUpdateAck_ref_t e2ap_E2NodeCompConfUpdateAck_clone(flatbuffers_builder_t *B, e2ap_E2NodeCompConfUpdateAck_table_t t);
__flatbuffers_build_table(flatbuffers_, e2ap_E2NodeCompConfUpdateAck, 3)

static const flatbuffers_voffset_t __e2ap_TransportLayerInformation_required[] = { 0 };
typedef flatbuffers_ref_t e2ap_TransportLayerInformation_ref_t;
static e2ap_TransportLayerInformation_ref_t e2ap_TransportLayerInformation_clone(flatbuffers_builder_t *B, e2ap_TransportLayerInformation_table_t t);
__flatbuffers_build_table(flatbuffers_, e2ap_TransportLayerInformation, 2)

static const flatbuffers_voffset_t __e2ap_GNB_required[] = { 0 };
typedef flatbuffers_ref_t e2ap_GNB_ref_t;
static e2ap_GNB_ref_t e2ap_GNB_clone(flatbuffers_builder_t *B, e2ap_GNB_table_t t);
__flatbuffers_build_table(flatbuffers_, e2ap_GNB, 4)

#define __e2ap_RicRequest_formal_args , e2ap_RicRequestCause_enum_t v0
#define __e2ap_RicRequest_call_args , v0
static inline e2ap_RicRequest_ref_t e2ap_RicRequest_create(flatbuffers_builder_t *B __e2ap_RicRequest_formal_args);
__flatbuffers_build_table_prolog(flatbuffers_, e2ap_RicRequest, e2ap_RicRequest_file_identifier, e2ap_RicRequest_type_identifier)

#define __e2ap_RicService_formal_args , e2ap_RicServiceCause_enum_t v0
#define __e2ap_RicService_call_args , v0
static inline e2ap_RicService_ref_t e2ap_RicService_create(flatbuffers_builder_t *B __e2ap_RicService_formal_args);
__flatbuffers_build_table_prolog(flatbuffers_, e2ap_RicService, e2ap_RicService_file_identifier, e2ap_RicService_type_identifier)

#define __e2ap_TransportLayer_formal_args , e2ap_TransportLayerCause_enum_t v0
#define __e2ap_TransportLayer_call_args , v0
static inline e2ap_TransportLayer_ref_t e2ap_TransportLayer_create(flatbuffers_builder_t *B __e2ap_TransportLayer_formal_args);
__flatbuffers_build_table_prolog(flatbuffers_, e2ap_TransportLayer, e2ap_TransportLayer_file_identifier, e2ap_TransportLayer_type_identifier)

#define __e2ap_Protocol_formal_args , e2ap_ProtocolCause_enum_t v0
#define __e2ap_Protocol_call_args , v0
static inline e2ap_Protocol_ref_t e2ap_Protocol_create(flatbuffers_builder_t *B __e2ap_Protocol_formal_args);
__flatbuffers_build_table_prolog(flatbuffers_, e2ap_Protocol, e2ap_Protocol_file_identifier, e2ap_Protocol_type_identifier)

#define __e2ap_Misc_formal_args , e2ap_MiscellaneousCause_enum_t v0
#define __e2ap_Misc_call_args , v0
static inline e2ap_Misc_ref_t e2ap_Misc_create(flatbuffers_builder_t *B __e2ap_Misc_formal_args);
__flatbuffers_build_table_prolog(flatbuffers_, e2ap_Misc, e2ap_Misc_file_identifier, e2ap_Misc_type_identifier)

#define __e2ap_IECriticalityDiagnostics_formal_args , e2ap_Criticality_enum_t v0, uint16_t v1, e2ap_TypeOfError_enum_t v2
#define __e2ap_IECriticalityDiagnostics_call_args , v0, v1, v2
static inline e2ap_IECriticalityDiagnostics_ref_t e2ap_IECriticalityDiagnostics_create(flatbuffers_builder_t *B __e2ap_IECriticalityDiagnostics_formal_args);
__flatbuffers_build_table_prolog(flatbuffers_, e2ap_IECriticalityDiagnostics, e2ap_IECriticalityDiagnostics_file_identifier, e2ap_IECriticalityDiagnostics_type_identifier)

#define __e2ap_CriticalityDiagnostics_formal_args , uint8_t v0, e2ap_TriggeringMessage_enum_t v1, e2ap_ProcedureCriticality_enum_t v2, e2ap_IECriticalityDiagnostics_vec_ref_t v3
#define __e2ap_CriticalityDiagnostics_call_args , v0, v1, v2, v3
static inline e2ap_CriticalityDiagnostics_ref_t e2ap_CriticalityDiagnostics_create(flatbuffers_builder_t *B __e2ap_CriticalityDiagnostics_formal_args);
__flatbuffers_build_table_prolog(flatbuffers_, e2ap_CriticalityDiagnostics, e2ap_CriticalityDiagnostics_file_identifier, e2ap_CriticalityDiagnostics_type_identifier)

#define __e2ap_GlobalRicId_formal_args , e2ap_Plmn_t *v0, uint32_t v1
#define __e2ap_GlobalRicId_call_args , v0, v1
static inline e2ap_GlobalRicId_ref_t e2ap_GlobalRicId_create(flatbuffers_builder_t *B __e2ap_GlobalRicId_formal_args);
__flatbuffers_build_table_prolog(flatbuffers_, e2ap_GlobalRicId, e2ap_GlobalRicId_file_identifier, e2ap_GlobalRicId_type_identifier)

#define __e2ap_RicSubsequentAction_formal_args , e2ap_RicSubsequentActionType_enum_t v0, uint32_t v1
#define __e2ap_RicSubsequentAction_call_args , v0, v1
static inline e2ap_RicSubsequentAction_ref_t e2ap_RicSubsequentAction_create(flatbuffers_builder_t *B __e2ap_RicSubsequentAction_formal_args);
__flatbuffers_build_table_prolog(flatbuffers_, e2ap_RicSubsequentAction, e2ap_RicSubsequentAction_file_identifier, e2ap_RicSubsequentAction_type_identifier)

#define __e2ap_gnbE2NodeCompConfUpdate_formal_args , flatbuffers_uint8_vec_ref_t v0, flatbuffers_uint8_vec_ref_t v1, flatbuffers_uint8_vec_ref_t v2, flatbuffers_uint8_vec_ref_t v3
#define __e2ap_gnbE2NodeCompConfUpdate_call_args , v0, v1, v2, v3
static inline e2ap_gnbE2NodeCompConfUpdate_ref_t e2ap_gnbE2NodeCompConfUpdate_create(flatbuffers_builder_t *B __e2ap_gnbE2NodeCompConfUpdate_formal_args);
__flatbuffers_build_table_prolog(flatbuffers_, e2ap_gnbE2NodeCompConfUpdate, e2ap_gnbE2NodeCompConfUpdate_file_identifier, e2ap_gnbE2NodeCompConfUpdate_type_identifier)

#define __e2ap_en_gnbE2NodeCompConfUpdate_formal_args , flatbuffers_uint8_vec_ref_t v0
#define __e2ap_en_gnbE2NodeCompConfUpdate_call_args , v0
static inline e2ap_en_gnbE2NodeCompConfUpdate_ref_t e2ap_en_gnbE2NodeCompConfUpdate_create(flatbuffers_builder_t *B __e2ap_en_gnbE2NodeCompConfUpdate_formal_args);
__flatbuffers_build_table_prolog(flatbuffers_, e2ap_en_gnbE2NodeCompConfUpdate, e2ap_en_gnbE2NodeCompConfUpdate_file_identifier, e2ap_en_gnbE2NodeCompConfUpdate_type_identifier)

#define __e2ap_ng_enbE2NodeCompConfUpdate_formal_args , flatbuffers_uint8_vec_ref_t v0, flatbuffers_uint8_vec_ref_t v1
#define __e2ap_ng_enbE2NodeCompConfUpdate_call_args , v0, v1
static inline e2ap_ng_enbE2NodeCompConfUpdate_ref_t e2ap_ng_enbE2NodeCompConfUpdate_create(flatbuffers_builder_t *B __e2ap_ng_enbE2NodeCompConfUpdate_formal_args);
__flatbuffers_build_table_prolog(flatbuffers_, e2ap_ng_enbE2NodeCompConfUpdate, e2ap_ng_enbE2NodeCompConfUpdate_file_identifier, e2ap_ng_enbE2NodeCompConfUpdate_type_identifier)

#define __e2ap_enbE2NodeCompConfUpdate_formal_args , flatbuffers_uint8_vec_ref_t v0, flatbuffers_uint8_vec_ref_t v1
#define __e2ap_enbE2NodeCompConfUpdate_call_args , v0, v1
static inline e2ap_enbE2NodeCompConfUpdate_ref_t e2ap_enbE2NodeCompConfUpdate_create(flatbuffers_builder_t *B __e2ap_enbE2NodeCompConfUpdate_formal_args);
__flatbuffers_build_table_prolog(flatbuffers_, e2ap_enbE2NodeCompConfUpdate, e2ap_enbE2NodeCompConfUpdate_file_identifier, e2ap_enbE2NodeCompConfUpdate_type_identifier)

#define __e2ap_E2NodeCompConfUpdateAck_formal_args , e2ap_E2NodeCompConfUpdateAckOutcome_enum_t v0, e2ap_Cause_union_ref_t v2
#define __e2ap_E2NodeCompConfUpdateAck_call_args , v0, v2
static inline e2ap_E2NodeCompConfUpdateAck_ref_t e2ap_E2NodeCompConfUpdateAck_create(flatbuffers_builder_t *B __e2ap_E2NodeCompConfUpdateAck_formal_args);
__flatbuffers_build_table_prolog(flatbuffers_, e2ap_E2NodeCompConfUpdateAck, e2ap_E2NodeCompConfUpdateAck_file_identifier, e2ap_E2NodeCompConfUpdateAck_type_identifier)

#define __e2ap_TransportLayerInformation_formal_args , flatbuffers_uint8_vec_ref_t v0, uint16_t v1
#define __e2ap_TransportLayerInformation_call_args , v0, v1
static inline e2ap_TransportLayerInformation_ref_t e2ap_TransportLayerInformation_create(flatbuffers_builder_t *B __e2ap_TransportLayerInformation_formal_args);
__flatbuffers_build_table_prolog(flatbuffers_, e2ap_TransportLayerInformation, e2ap_TransportLayerInformation_file_identifier, e2ap_TransportLayerInformation_type_identifier)

#define __e2ap_GNB_formal_args , e2ap_Plmn_t *v0, uint32_t v1, uint64_t v2, uint64_t v3
#define __e2ap_GNB_call_args , v0, v1, v2, v3
static inline e2ap_GNB_ref_t e2ap_GNB_create(flatbuffers_builder_t *B __e2ap_GNB_formal_args);
__flatbuffers_build_table_prolog(flatbuffers_, e2ap_GNB, e2ap_GNB_file_identifier, e2ap_GNB_type_identifier)

static inline e2ap_Cause_union_ref_t e2ap_Cause_as_NONE(void)
{ e2ap_Cause_union_ref_t uref; uref.type = e2ap_Cause_NONE; uref.value = 0; return uref; }
static inline e2ap_Cause_union_ref_t e2ap_Cause_as_ricRequest(e2ap_RicRequest_ref_t ref)
{ e2ap_Cause_union_ref_t uref; uref.type = e2ap_Cause_ricRequest; uref.value = ref; return uref; }
static inline e2ap_Cause_union_ref_t e2ap_Cause_as_ricService(e2ap_RicService_ref_t ref)
{ e2ap_Cause_union_ref_t uref; uref.type = e2ap_Cause_ricService; uref.value = ref; return uref; }
static inline e2ap_Cause_union_ref_t e2ap_Cause_as_transportLayer(e2ap_TransportLayer_ref_t ref)
{ e2ap_Cause_union_ref_t uref; uref.type = e2ap_Cause_transportLayer; uref.value = ref; return uref; }
static inline e2ap_Cause_union_ref_t e2ap_Cause_as_protocol(e2ap_Protocol_ref_t ref)
{ e2ap_Cause_union_ref_t uref; uref.type = e2ap_Cause_protocol; uref.value = ref; return uref; }
static inline e2ap_Cause_union_ref_t e2ap_Cause_as_misc(e2ap_Misc_ref_t ref)
{ e2ap_Cause_union_ref_t uref; uref.type = e2ap_Cause_misc; uref.value = ref; return uref; }
__flatbuffers_build_union_vector(flatbuffers_, e2ap_Cause)

static e2ap_Cause_union_ref_t e2ap_Cause_clone(flatbuffers_builder_t *B, e2ap_Cause_union_t u)
{
    switch (u.type) {
    case 1: return e2ap_Cause_as_ricRequest(e2ap_RicRequest_clone(B, (e2ap_RicRequest_table_t)u.value));
    case 2: return e2ap_Cause_as_ricService(e2ap_RicService_clone(B, (e2ap_RicService_table_t)u.value));
    case 3: return e2ap_Cause_as_transportLayer(e2ap_TransportLayer_clone(B, (e2ap_TransportLayer_table_t)u.value));
    case 4: return e2ap_Cause_as_protocol(e2ap_Protocol_clone(B, (e2ap_Protocol_table_t)u.value));
    case 5: return e2ap_Cause_as_misc(e2ap_Misc_clone(B, (e2ap_Misc_table_t)u.value));
    default: return e2ap_Cause_as_NONE();
    }
}

static inline e2ap_GlobalE2NodeId_union_ref_t e2ap_GlobalE2NodeId_as_NONE(void)
{ e2ap_GlobalE2NodeId_union_ref_t uref; uref.type = e2ap_GlobalE2NodeId_NONE; uref.value = 0; return uref; }
static inline e2ap_GlobalE2NodeId_union_ref_t e2ap_GlobalE2NodeId_as_gNB(e2ap_GNB_ref_t ref)
{ e2ap_GlobalE2NodeId_union_ref_t uref; uref.type = e2ap_GlobalE2NodeId_gNB; uref.value = ref; return uref; }
static inline e2ap_GlobalE2NodeId_union_ref_t e2ap_GlobalE2NodeId_as_engNB(e2ap_EngNB_ref_t ref)
{ e2ap_GlobalE2NodeId_union_ref_t uref; uref.type = e2ap_GlobalE2NodeId_engNB; uref.value = ref; return uref; }
static inline e2ap_GlobalE2NodeId_union_ref_t e2ap_GlobalE2NodeId_as_ngeNB(e2ap_NgeNB_ref_t ref)
{ e2ap_GlobalE2NodeId_union_ref_t uref; uref.type = e2ap_GlobalE2NodeId_ngeNB; uref.value = ref; return uref; }
static inline e2ap_GlobalE2NodeId_union_ref_t e2ap_GlobalE2NodeId_as_eNB(e2ap_ENB_ref_t ref)
{ e2ap_GlobalE2NodeId_union_ref_t uref; uref.type = e2ap_GlobalE2NodeId_eNB; uref.value = ref; return uref; }
__flatbuffers_build_union_vector(flatbuffers_, e2ap_GlobalE2NodeId)

static e2ap_GlobalE2NodeId_union_ref_t e2ap_GlobalE2NodeId_clone(flatbuffers_builder_t *B, e2ap_GlobalE2NodeId_union_t u)
{
    switch (u.type) {
    case 1: return e2ap_GlobalE2NodeId_as_gNB(e2ap_GNB_clone(B, (e2ap_GNB_table_t)u.value));
    case 2: return e2ap_GlobalE2NodeId_as_engNB(e2ap_EngNB_clone(B, (e2ap_EngNB_struct_t)u.value));
    case 3: return e2ap_GlobalE2NodeId_as_ngeNB(e2ap_NgeNB_clone(B, (e2ap_NgeNB_struct_t)u.value));
    case 4: return e2ap_GlobalE2NodeId_as_eNB(e2ap_ENB_clone(B, (e2ap_ENB_struct_t)u.value));
    default: return e2ap_GlobalE2NodeId_as_NONE();
    }
}

static inline e2ap_E2NodeCompConfUpdate_union_ref_t e2ap_E2NodeCompConfUpdate_as_NONE(void)
{ e2ap_E2NodeCompConfUpdate_union_ref_t uref; uref.type = e2ap_E2NodeCompConfUpdate_NONE; uref.value = 0; return uref; }
static inline e2ap_E2NodeCompConfUpdate_union_ref_t e2ap_E2NodeCompConfUpdate_as_gnb(e2ap_gnbE2NodeCompConfUpdate_ref_t ref)
{ e2ap_E2NodeCompConfUpdate_union_ref_t uref; uref.type = e2ap_E2NodeCompConfUpdate_gnb; uref.value = ref; return uref; }
static inline e2ap_E2NodeCompConfUpdate_union_ref_t e2ap_E2NodeCompConfUpdate_as_en_gnb(e2ap_en_gnbE2NodeCompConfUpdate_ref_t ref)
{ e2ap_E2NodeCompConfUpdate_union_ref_t uref; uref.type = e2ap_E2NodeCompConfUpdate_en_gnb; uref.value = ref; return uref; }
static inline e2ap_E2NodeCompConfUpdate_union_ref_t e2ap_E2NodeCompConfUpdate_as_ng_enb(e2ap_ng_enbE2NodeCompConfUpdate_ref_t ref)
{ e2ap_E2NodeCompConfUpdate_union_ref_t uref; uref.type = e2ap_E2NodeCompConfUpdate_ng_enb; uref.value = ref; return uref; }
static inline e2ap_E2NodeCompConfUpdate_union_ref_t e2ap_E2NodeCompConfUpdate_as_enb(e2ap_enbE2NodeCompConfUpdate_ref_t ref)
{ e2ap_E2NodeCompConfUpdate_union_ref_t uref; uref.type = e2ap_E2NodeCompConfUpdate_enb; uref.value = ref; return uref; }
__flatbuffers_build_union_vector(flatbuffers_, e2ap_E2NodeCompConfUpdate)

static e2ap_E2NodeCompConfUpdate_union_ref_t e2ap_E2NodeCompConfUpdate_clone(flatbuffers_builder_t *B, e2ap_E2NodeCompConfUpdate_union_t u)
{
    switch (u.type) {
    case 1: return e2ap_E2NodeCompConfUpdate_as_gnb(e2ap_gnbE2NodeCompConfUpdate_clone(B, (e2ap_gnbE2NodeCompConfUpdate_table_t)u.value));
    case 2: return e2ap_E2NodeCompConfUpdate_as_en_gnb(e2ap_en_gnbE2NodeCompConfUpdate_clone(B, (e2ap_en_gnbE2NodeCompConfUpdate_table_t)u.value));
    case 3: return e2ap_E2NodeCompConfUpdate_as_ng_enb(e2ap_ng_enbE2NodeCompConfUpdate_clone(B, (e2ap_ng_enbE2NodeCompConfUpdate_table_t)u.value));
    case 4: return e2ap_E2NodeCompConfUpdate_as_enb(e2ap_enbE2NodeCompConfUpdate_clone(B, (e2ap_enbE2NodeCompConfUpdate_table_t)u.value));
    default: return e2ap_E2NodeCompConfUpdate_as_NONE();
    }
}

static inline e2ap_E2NodeCompId_union_ref_t e2ap_E2NodeCompId_as_NONE(void)
{ e2ap_E2NodeCompId_union_ref_t uref; uref.type = e2ap_E2NodeCompId_NONE; uref.value = 0; return uref; }
static inline e2ap_E2NodeCompId_union_ref_t e2ap_E2NodeCompId_as_gnb_cu_up(e2ap_E2NCId_ref_t ref)
{ e2ap_E2NodeCompId_union_ref_t uref; uref.type = e2ap_E2NodeCompId_gnb_cu_up; uref.value = ref; return uref; }
static inline e2ap_E2NodeCompId_union_ref_t e2ap_E2NodeCompId_as_gnb_du(e2ap_E2NCId_ref_t ref)
{ e2ap_E2NodeCompId_union_ref_t uref; uref.type = e2ap_E2NodeCompId_gnb_du; uref.value = ref; return uref; }
__flatbuffers_build_union_vector(flatbuffers_, e2ap_E2NodeCompId)

static e2ap_E2NodeCompId_union_ref_t e2ap_E2NodeCompId_clone(flatbuffers_builder_t *B, e2ap_E2NodeCompId_union_t u)
{
    switch (u.type) {
    case 1: return e2ap_E2NodeCompId_as_gnb_cu_up(e2ap_E2NCId_clone(B, (e2ap_E2NCId_struct_t)u.value));
    case 2: return e2ap_E2NodeCompId_as_gnb_du(e2ap_E2NCId_clone(B, (e2ap_E2NCId_struct_t)u.value));
    default: return e2ap_E2NodeCompId_as_NONE();
    }
}

__flatbuffers_build_scalar_field(0, flatbuffers_, e2ap_RicRequest_ricRequestCause, e2ap_RicRequestCause, e2ap_RicRequestCause_enum_t, 1, 1, UINT8_C(0), e2ap_RicRequest)

static inline e2ap_RicRequest_ref_t e2ap_RicRequest_create(flatbuffers_builder_t *B __e2ap_RicRequest_formal_args)
{
    if (e2ap_RicRequest_start(B)
        || e2ap_RicRequest_ricRequestCause_add(B, v0)) {
        return 0;
    }
    return e2ap_RicRequest_end(B);
}

static e2ap_RicRequest_ref_t e2ap_RicRequest_clone(flatbuffers_builder_t *B, e2ap_RicRequest_table_t t)
{
    __flatbuffers_memoize_begin(B, t);
    if (e2ap_RicRequest_start(B)
        || e2ap_RicRequest_ricRequestCause_pick(B, t)) {
        return 0;
    }
    __flatbuffers_memoize_end(B, t, e2ap_RicRequest_end(B));
}

__flatbuffers_build_scalar_field(0, flatbuffers_, e2ap_RicService_ricServiceCause, e2ap_RicServiceCause, e2ap_RicServiceCause_enum_t, 1, 1, UINT8_C(0), e2ap_RicService)

static inline e2ap_RicService_ref_t e2ap_RicService_create(flatbuffers_builder_t *B __e2ap_RicService_formal_args)
{
    if (e2ap_RicService_start(B)
        || e2ap_RicService_ricServiceCause_add(B, v0)) {
        return 0;
    }
    return e2ap_RicService_end(B);
}

static e2ap_RicService_ref_t e2ap_RicService_clone(flatbuffers_builder_t *B, e2ap_RicService_table_t t)
{
    __flatbuffers_memoize_begin(B, t);
    if (e2ap_RicService_start(B)
        || e2ap_RicService_ricServiceCause_pick(B, t)) {
        return 0;
    }
    __flatbuffers_memoize_end(B, t, e2ap_RicService_end(B));
}

__flatbuffers_build_scalar_field(0, flatbuffers_, e2ap_TransportLayer_transportLayerCause, e2ap_TransportLayerCause, e2ap_TransportLayerCause_enum_t, 1, 1, UINT8_C(0), e2ap_TransportLayer)

static inline e2ap_TransportLayer_ref_t e2ap_TransportLayer_create(flatbuffers_builder_t *B __e2ap_TransportLayer_formal_args)
{
    if (e2ap_TransportLayer_start(B)
        || e2ap_TransportLayer_transportLayerCause_add(B, v0)) {
        return 0;
    }
    return e2ap_TransportLayer_end(B);
}

static e2ap_TransportLayer_ref_t e2ap_TransportLayer_clone(flatbuffers_builder_t *B, e2ap_TransportLayer_table_t t)
{
    __flatbuffers_memoize_begin(B, t);
    if (e2ap_TransportLayer_start(B)
        || e2ap_TransportLayer_transportLayerCause_pick(B, t)) {
        return 0;
    }
    __flatbuffers_memoize_end(B, t, e2ap_TransportLayer_end(B));
}

__flatbuffers_build_scalar_field(0, flatbuffers_, e2ap_Protocol_protocolCause, e2ap_ProtocolCause, e2ap_ProtocolCause_enum_t, 1, 1, UINT8_C(0), e2ap_Protocol)

static inline e2ap_Protocol_ref_t e2ap_Protocol_create(flatbuffers_builder_t *B __e2ap_Protocol_formal_args)
{
    if (e2ap_Protocol_start(B)
        || e2ap_Protocol_protocolCause_add(B, v0)) {
        return 0;
    }
    return e2ap_Protocol_end(B);
}

static e2ap_Protocol_ref_t e2ap_Protocol_clone(flatbuffers_builder_t *B, e2ap_Protocol_table_t t)
{
    __flatbuffers_memoize_begin(B, t);
    if (e2ap_Protocol_start(B)
        || e2ap_Protocol_protocolCause_pick(B, t)) {
        return 0;
    }
    __flatbuffers_memoize_end(B, t, e2ap_Protocol_end(B));
}

__flatbuffers_build_scalar_field(0, flatbuffers_, e2ap_Misc_miscellaneousCause, e2ap_MiscellaneousCause, e2ap_MiscellaneousCause_enum_t, 1, 1, UINT8_C(0), e2ap_Misc)

static inline e2ap_Misc_ref_t e2ap_Misc_create(flatbuffers_builder_t *B __e2ap_Misc_formal_args)
{
    if (e2ap_Misc_start(B)
        || e2ap_Misc_miscellaneousCause_add(B, v0)) {
        return 0;
    }
    return e2ap_Misc_end(B);
}

static e2ap_Misc_ref_t e2ap_Misc_clone(flatbuffers_builder_t *B, e2ap_Misc_table_t t)
{
    __flatbuffers_memoize_begin(B, t);
    if (e2ap_Misc_start(B)
        || e2ap_Misc_miscellaneousCause_pick(B, t)) {
        return 0;
    }
    __flatbuffers_memoize_end(B, t, e2ap_Misc_end(B));
}

__flatbuffers_build_scalar_field(0, flatbuffers_, e2ap_IECriticalityDiagnostics_criticality, e2ap_Criticality, e2ap_Criticality_enum_t, 1, 1, UINT8_C(0), e2ap_IECriticalityDiagnostics)
__flatbuffers_build_scalar_field(1, flatbuffers_, e2ap_IECriticalityDiagnostics_ieId, flatbuffers_uint16, uint16_t, 2, 2, UINT16_C(0), e2ap_IECriticalityDiagnostics)
__flatbuffers_build_scalar_field(2, flatbuffers_, e2ap_IECriticalityDiagnostics_typeOfError, e2ap_TypeOfError, e2ap_TypeOfError_enum_t, 1, 1, UINT8_C(0), e2ap_IECriticalityDiagnostics)

static inline e2ap_IECriticalityDiagnostics_ref_t e2ap_IECriticalityDiagnostics_create(flatbuffers_builder_t *B __e2ap_IECriticalityDiagnostics_formal_args)
{
    if (e2ap_IECriticalityDiagnostics_start(B)
        || e2ap_IECriticalityDiagnostics_ieId_add(B, v1)
        || e2ap_IECriticalityDiagnostics_criticality_add(B, v0)
        || e2ap_IECriticalityDiagnostics_typeOfError_add(B, v2)) {
        return 0;
    }
    return e2ap_IECriticalityDiagnostics_end(B);
}

static e2ap_IECriticalityDiagnostics_ref_t e2ap_IECriticalityDiagnostics_clone(flatbuffers_builder_t *B, e2ap_IECriticalityDiagnostics_table_t t)
{
    __flatbuffers_memoize_begin(B, t);
    if (e2ap_IECriticalityDiagnostics_start(B)
        || e2ap_IECriticalityDiagnostics_ieId_pick(B, t)
        || e2ap_IECriticalityDiagnostics_criticality_pick(B, t)
        || e2ap_IECriticalityDiagnostics_typeOfError_pick(B, t)) {
        return 0;
    }
    __flatbuffers_memoize_end(B, t, e2ap_IECriticalityDiagnostics_end(B));
}

__flatbuffers_build_scalar_field(0, flatbuffers_, e2ap_CriticalityDiagnostics_procedureCode, flatbuffers_uint8, uint8_t, 1, 1, UINT8_C(0), e2ap_CriticalityDiagnostics)
__flatbuffers_build_scalar_field(1, flatbuffers_, e2ap_CriticalityDiagnostics_triggeringMessage, e2ap_TriggeringMessage, e2ap_TriggeringMessage_enum_t, 1, 1, UINT8_C(0), e2ap_CriticalityDiagnostics)
__flatbuffers_build_scalar_field(2, flatbuffers_, e2ap_CriticalityDiagnostics_procedureCriticality, e2ap_ProcedureCriticality, e2ap_ProcedureCriticality_enum_t, 1, 1, UINT8_C(0), e2ap_CriticalityDiagnostics)
__flatbuffers_build_table_vector_field(3, flatbuffers_, e2ap_CriticalityDiagnostics_ieCriticalityDiagnostics, e2ap_IECriticalityDiagnostics, e2ap_CriticalityDiagnostics)

static inline e2ap_CriticalityDiagnostics_ref_t e2ap_CriticalityDiagnostics_create(flatbuffers_builder_t *B __e2ap_CriticalityDiagnostics_formal_args)
{
    if (e2ap_CriticalityDiagnostics_start(B)
        || e2ap_CriticalityDiagnostics_ieCriticalityDiagnostics_add(B, v3)
        || e2ap_CriticalityDiagnostics_procedureCode_add(B, v0)
        || e2ap_CriticalityDiagnostics_triggeringMessage_add(B, v1)
        || e2ap_CriticalityDiagnostics_procedureCriticality_add(B, v2)) {
        return 0;
    }
    return e2ap_CriticalityDiagnostics_end(B);
}

static e2ap_CriticalityDiagnostics_ref_t e2ap_CriticalityDiagnostics_clone(flatbuffers_builder_t *B, e2ap_CriticalityDiagnostics_table_t t)
{
    __flatbuffers_memoize_begin(B, t);
    if (e2ap_CriticalityDiagnostics_start(B)
        || e2ap_CriticalityDiagnostics_ieCriticalityDiagnostics_pick(B, t)
        || e2ap_CriticalityDiagnostics_procedureCode_pick(B, t)
        || e2ap_CriticalityDiagnostics_triggeringMessage_pick(B, t)
        || e2ap_CriticalityDiagnostics_procedureCriticality_pick(B, t)) {
        return 0;
    }
    __flatbuffers_memoize_end(B, t, e2ap_CriticalityDiagnostics_end(B));
}

__flatbuffers_build_struct_field(0, flatbuffers_, e2ap_GlobalRicId_plmn, e2ap_Plmn, 6, 2, e2ap_GlobalRicId)
__flatbuffers_build_scalar_field(1, flatbuffers_, e2ap_GlobalRicId_nearRtRicId, flatbuffers_uint32, uint32_t, 4, 4, UINT32_C(0), e2ap_GlobalRicId)

static inline e2ap_GlobalRicId_ref_t e2ap_GlobalRicId_create(flatbuffers_builder_t *B __e2ap_GlobalRicId_formal_args)
{
    if (e2ap_GlobalRicId_start(B)
        || e2ap_GlobalRicId_nearRtRicId_add(B, v1)
        || e2ap_GlobalRicId_plmn_add(B, v0)) {
        return 0;
    }
    return e2ap_GlobalRicId_end(B);
}

static e2ap_GlobalRicId_ref_t e2ap_GlobalRicId_clone(flatbuffers_builder_t *B, e2ap_GlobalRicId_table_t t)
{
    __flatbuffers_memoize_begin(B, t);
    if (e2ap_GlobalRicId_start(B)
        || e2ap_GlobalRicId_nearRtRicId_pick(B, t)
        || e2ap_GlobalRicId_plmn_pick(B, t)) {
        return 0;
    }
    __flatbuffers_memoize_end(B, t, e2ap_GlobalRicId_end(B));
}

__flatbuffers_build_scalar_field(0, flatbuffers_, e2ap_RicSubsequentAction_type, e2ap_RicSubsequentActionType, e2ap_RicSubsequentActionType_enum_t, 1, 1, UINT8_C(0), e2ap_RicSubsequentAction)
__flatbuffers_build_scalar_field(1, flatbuffers_, e2ap_RicSubsequentAction_timeToWait, flatbuffers_uint32, uint32_t, 4, 4, UINT32_C(0), e2ap_RicSubsequentAction)

static inline e2ap_RicSubsequentAction_ref_t e2ap_RicSubsequentAction_create(flatbuffers_builder_t *B __e2ap_RicSubsequentAction_formal_args)
{
    if (e2ap_RicSubsequentAction_start(B)
        || e2ap_RicSubsequentAction_timeToWait_add(B, v1)
        || e2ap_RicSubsequentAction_type_add(B, v0)) {
        return 0;
    }
    return e2ap_RicSubsequentAction_end(B);
}

static e2ap_RicSubsequentAction_ref_t e2ap_RicSubsequentAction_clone(flatbuffers_builder_t *B, e2ap_RicSubsequentAction_table_t t)
{
    __flatbuffers_memoize_begin(B, t);
    if (e2ap_RicSubsequentAction_start(B)
        || e2ap_RicSubsequentAction_timeToWait_pick(B, t)
        || e2ap_RicSubsequentAction_type_pick(B, t)) {
        return 0;
    }
    __flatbuffers_memoize_end(B, t, e2ap_RicSubsequentAction_end(B));
}

__flatbuffers_build_vector_field(0, flatbuffers_, e2ap_gnbE2NodeCompConfUpdate_ngap_gnb_cu_cp, flatbuffers_uint8, uint8_t, e2ap_gnbE2NodeCompConfUpdate)
__flatbuffers_build_vector_field(1, flatbuffers_, e2ap_gnbE2NodeCompConfUpdate_xnap_gnb_cu_cp, flatbuffers_uint8, uint8_t, e2ap_gnbE2NodeCompConfUpdate)
__flatbuffers_build_vector_field(2, flatbuffers_, e2ap_gnbE2NodeCompConfUpdate_e1ap_gnb_cu_cp, flatbuffers_uint8, uint8_t, e2ap_gnbE2NodeCompConfUpdate)
__flatbuffers_build_vector_field(3, flatbuffers_, e2ap_gnbE2NodeCompConfUpdate_f1ap_gnb_cu_cp, flatbuffers_uint8, uint8_t, e2ap_gnbE2NodeCompConfUpdate)

static inline e2ap_gnbE2NodeCompConfUpdate_ref_t e2ap_gnbE2NodeCompConfUpdate_create(flatbuffers_builder_t *B __e2ap_gnbE2NodeCompConfUpdate_formal_args)
{
    if (e2ap_gnbE2NodeCompConfUpdate_start(B)
        || e2ap_gnbE2NodeCompConfUpdate_ngap_gnb_cu_cp_add(B, v0)
        || e2ap_gnbE2NodeCompConfUpdate_xnap_gnb_cu_cp_add(B, v1)
        || e2ap_gnbE2NodeCompConfUpdate_e1ap_gnb_cu_cp_add(B, v2)
        || e2ap_gnbE2NodeCompConfUpdate_f1ap_gnb_cu_cp_add(B, v3)) {
        return 0;
    }
    return e2ap_gnbE2NodeCompConfUpdate_end(B);
}

static e2ap_gnbE2NodeCompConfUpdate_ref_t e2ap_gnbE2NodeCompConfUpdate_clone(flatbuffers_builder_t *B, e2ap_gnbE2NodeCompConfUpdate_table_t t)
{
    __flatbuffers_memoize_begin(B, t);
    if (e2ap_gnbE2NodeCompConfUpdate_start(B)
        || e2ap_gnbE2NodeCompConfUpdate_ngap_gnb_cu_cp_pick(B, t)
        || e2ap_gnbE2NodeCompConfUpdate_xnap_gnb_cu_cp_pick(B, t)
        || e2ap_gnbE2NodeCompConfUpdate_e1ap_gnb_cu_cp_pick(B, t)
        || e2ap_gnbE2NodeCompConfUpdate_f1ap_gnb_cu_cp_pick(B, t)) {
        return 0;
    }
    __flatbuffers_memoize_end(B, t, e2ap_gnbE2NodeCompConfUpdate_end(B));
}

__flatbuffers_build_vector_field(0, flatbuffers_, e2ap_en_gnbE2NodeCompConfUpdate_x2ap_en_gnb, flatbuffers_uint8, uint8_t, e2ap_en_gnbE2NodeCompConfUpdate)

static inline e2ap_en_gnbE2NodeCompConfUpdate_ref_t e2ap_en_gnbE2NodeCompConfUpdate_create(flatbuffers_builder_t *B __e2ap_en_gnbE2NodeCompConfUpdate_formal_args)
{
    if (e2ap_en_gnbE2NodeCompConfUpdate_start(B)
        || e2ap_en_gnbE2NodeCompConfUpdate_x2ap_en_gnb_add(B, v0)) {
        return 0;
    }
    return e2ap_en_gnbE2NodeCompConfUpdate_end(B);
}

static e2ap_en_gnbE2NodeCompConfUpdate_ref_t e2ap_en_gnbE2NodeCompConfUpdate_clone(flatbuffers_builder_t *B, e2ap_en_gnbE2NodeCompConfUpdate_table_t t)
{
    __flatbuffers_memoize_begin(B, t);
    if (e2ap_en_gnbE2NodeCompConfUpdate_start(B)
        || e2ap_en_gnbE2NodeCompConfUpdate_x2ap_en_gnb_pick(B, t)) {
        return 0;
    }
    __flatbuffers_memoize_end(B, t, e2ap_en_gnbE2NodeCompConfUpdate_end(B));
}

__flatbuffers_build_vector_field(0, flatbuffers_, e2ap_ng_enbE2NodeCompConfUpdate_ngap_ng_enb, flatbuffers_uint8, uint8_t, e2ap_ng_enbE2NodeCompConfUpdate)
__flatbuffers_build_vector_field(1, flatbuffers_, e2ap_ng_enbE2NodeCompConfUpdate_xap_ng_enb, flatbuffers_uint8, uint8_t, e2ap_ng_enbE2NodeCompConfUpdate)

static inline e2ap_ng_enbE2NodeCompConfUpdate_ref_t e2ap_ng_enbE2NodeCompConfUpdate_create(flatbuffers_builder_t *B __e2ap_ng_enbE2NodeCompConfUpdate_formal_args)
{
    if (e2ap_ng_enbE2NodeCompConfUpdate_start(B)
        || e2ap_ng_enbE2NodeCompConfUpdate_ngap_ng_enb_add(B, v0)
        || e2ap_ng_enbE2NodeCompConfUpdate_xap_ng_enb_add(B, v1)) {
        return 0;
    }
    return e2ap_ng_enbE2NodeCompConfUpdate_end(B);
}

static e2ap_ng_enbE2NodeCompConfUpdate_ref_t e2ap_ng_enbE2NodeCompConfUpdate_clone(flatbuffers_builder_t *B, e2ap_ng_enbE2NodeCompConfUpdate_table_t t)
{
    __flatbuffers_memoize_begin(B, t);
    if (e2ap_ng_enbE2NodeCompConfUpdate_start(B)
        || e2ap_ng_enbE2NodeCompConfUpdate_ngap_ng_enb_pick(B, t)
        || e2ap_ng_enbE2NodeCompConfUpdate_xap_ng_enb_pick(B, t)) {
        return 0;
    }
    __flatbuffers_memoize_end(B, t, e2ap_ng_enbE2NodeCompConfUpdate_end(B));
}

__flatbuffers_build_vector_field(0, flatbuffers_, e2ap_enbE2NodeCompConfUpdate_s1ap_enb, flatbuffers_uint8, uint8_t, e2ap_enbE2NodeCompConfUpdate)
__flatbuffers_build_vector_field(1, flatbuffers_, e2ap_enbE2NodeCompConfUpdate_x2ap_enb, flatbuffers_uint8, uint8_t, e2ap_enbE2NodeCompConfUpdate)

static inline e2ap_enbE2NodeCompConfUpdate_ref_t e2ap_enbE2NodeCompConfUpdate_create(flatbuffers_builder_t *B __e2ap_enbE2NodeCompConfUpdate_formal_args)
{
    if (e2ap_enbE2NodeCompConfUpdate_start(B)
        || e2ap_enbE2NodeCompConfUpdate_s1ap_enb_add(B, v0)
        || e2ap_enbE2NodeCompConfUpdate_x2ap_enb_add(B, v1)) {
        return 0;
    }
    return e2ap_enbE2NodeCompConfUpdate_end(B);
}

static e2ap_enbE2NodeCompConfUpdate_ref_t e2ap_enbE2NodeCompConfUpdate_clone(flatbuffers_builder_t *B, e2ap_enbE2NodeCompConfUpdate_table_t t)
{
    __flatbuffers_memoize_begin(B, t);
    if (e2ap_enbE2NodeCompConfUpdate_start(B)
        || e2ap_enbE2NodeCompConfUpdate_s1ap_enb_pick(B, t)
        || e2ap_enbE2NodeCompConfUpdate_x2ap_enb_pick(B, t)) {
        return 0;
    }
    __flatbuffers_memoize_end(B, t, e2ap_enbE2NodeCompConfUpdate_end(B));
}

__flatbuffers_build_scalar_field(0, flatbuffers_, e2ap_E2NodeCompConfUpdateAck_outcome, e2ap_E2NodeCompConfUpdateAckOutcome, e2ap_E2NodeCompConfUpdateAckOutcome_enum_t, 1, 1, UINT8_C(0), e2ap_E2NodeCompConfUpdateAck)
__flatbuffers_build_union_field(2, flatbuffers_, e2ap_E2NodeCompConfUpdateAck_cause, e2ap_Cause, e2ap_E2NodeCompConfUpdateAck)
__flatbuffers_build_union_table_value_field(flatbuffers_, e2ap_E2NodeCompConfUpdateAck_cause, e2ap_Cause, ricRequest, e2ap_RicRequest)
__flatbuffers_build_union_table_value_field(flatbuffers_, e2ap_E2NodeCompConfUpdateAck_cause, e2ap_Cause, ricService, e2ap_RicService)
__flatbuffers_build_union_table_value_field(flatbuffers_, e2ap_E2NodeCompConfUpdateAck_cause, e2ap_Cause, transportLayer, e2ap_TransportLayer)
__flatbuffers_build_union_table_value_field(flatbuffers_, e2ap_E2NodeCompConfUpdateAck_cause, e2ap_Cause, protocol, e2ap_Protocol)
__flatbuffers_build_union_table_value_field(flatbuffers_, e2ap_E2NodeCompConfUpdateAck_cause, e2ap_Cause, misc, e2ap_Misc)

static inline e2ap_E2NodeCompConfUpdateAck_ref_t e2ap_E2NodeCompConfUpdateAck_create(flatbuffers_builder_t *B __e2ap_E2NodeCompConfUpdateAck_formal_args)
{
    if (e2ap_E2NodeCompConfUpdateAck_start(B)
        || e2ap_E2NodeCompConfUpdateAck_cause_add_value(B, v2)
        || e2ap_E2NodeCompConfUpdateAck_outcome_add(B, v0)
        || e2ap_E2NodeCompConfUpdateAck_cause_add_type(B, v2.type)) {
        return 0;
    }
    return e2ap_E2NodeCompConfUpdateAck_end(B);
}

static e2ap_E2NodeCompConfUpdateAck_ref_t e2ap_E2NodeCompConfUpdateAck_clone(flatbuffers_builder_t *B, e2ap_E2NodeCompConfUpdateAck_table_t t)
{
    __flatbuffers_memoize_begin(B, t);
    if (e2ap_E2NodeCompConfUpdateAck_start(B)
        || e2ap_E2NodeCompConfUpdateAck_cause_pick(B, t)
        || e2ap_E2NodeCompConfUpdateAck_outcome_pick(B, t)) {
        return 0;
    }
    __flatbuffers_memoize_end(B, t, e2ap_E2NodeCompConfUpdateAck_end(B));
}

__flatbuffers_build_vector_field(0, flatbuffers_, e2ap_TransportLayerInformation_transportLayerAddress, flatbuffers_uint8, uint8_t, e2ap_TransportLayerInformation)
__flatbuffers_build_scalar_field(1, flatbuffers_, e2ap_TransportLayerInformation_transportLayerPort, flatbuffers_uint16, uint16_t, 2, 2, UINT16_C(0), e2ap_TransportLayerInformation)

static inline e2ap_TransportLayerInformation_ref_t e2ap_TransportLayerInformation_create(flatbuffers_builder_t *B __e2ap_TransportLayerInformation_formal_args)
{
    if (e2ap_TransportLayerInformation_start(B)
        || e2ap_TransportLayerInformation_transportLayerAddress_add(B, v0)
        || e2ap_TransportLayerInformation_transportLayerPort_add(B, v1)) {
        return 0;
    }
    return e2ap_TransportLayerInformation_end(B);
}

static e2ap_TransportLayerInformation_ref_t e2ap_TransportLayerInformation_clone(flatbuffers_builder_t *B, e2ap_TransportLayerInformation_table_t t)
{
    __flatbuffers_memoize_begin(B, t);
    if (e2ap_TransportLayerInformation_start(B)
        || e2ap_TransportLayerInformation_transportLayerAddress_pick(B, t)
        || e2ap_TransportLayerInformation_transportLayerPort_pick(B, t)) {
        return 0;
    }
    __flatbuffers_memoize_end(B, t, e2ap_TransportLayerInformation_end(B));
}

__flatbuffers_build_struct_field(0, flatbuffers_, e2ap_GNB_plmn, e2ap_Plmn, 6, 2, e2ap_GNB)
__flatbuffers_build_scalar_field(1, flatbuffers_, e2ap_GNB_id, flatbuffers_uint32, uint32_t, 4, 4, UINT32_C(0), e2ap_GNB)
__flatbuffers_build_scalar_field(2, flatbuffers_, e2ap_GNB_cu_up_id, flatbuffers_uint64, uint64_t, 8, 8, UINT64_C(0), e2ap_GNB)
__flatbuffers_build_scalar_field(3, flatbuffers_, e2ap_GNB_du_id, flatbuffers_uint64, uint64_t, 8, 8, UINT64_C(0), e2ap_GNB)

static inline e2ap_GNB_ref_t e2ap_GNB_create(flatbuffers_builder_t *B __e2ap_GNB_formal_args)
{
    if (e2ap_GNB_start(B)
        || e2ap_GNB_cu_up_id_add(B, v2)
        || e2ap_GNB_du_id_add(B, v3)
        || e2ap_GNB_id_add(B, v1)
        || e2ap_GNB_plmn_add(B, v0)) {
        return 0;
    }
    return e2ap_GNB_end(B);
}

static e2ap_GNB_ref_t e2ap_GNB_clone(flatbuffers_builder_t *B, e2ap_GNB_table_t t)
{
    __flatbuffers_memoize_begin(B, t);
    if (e2ap_GNB_start(B)
        || e2ap_GNB_cu_up_id_pick(B, t)
        || e2ap_GNB_du_id_pick(B, t)
        || e2ap_GNB_id_pick(B, t)
        || e2ap_GNB_plmn_pick(B, t)) {
        return 0;
    }
    __flatbuffers_memoize_end(B, t, e2ap_GNB_end(B));
}

#include "flatcc/flatcc_epilogue.h"
#endif /* IE_DEFINITIONS_BUILDER_H */
